const CryptoJS = require('../../crypto-full.js');
const request = require('../../utils/request.js');
const imageUtil = require('../../utils/image.js');
const api = require('../../utils/api.js');      // 🔥 引入API工具类
const storage = require('../../utils/storage.js'); // 🔥 引入存储工具类

const app = getApp();

const unreadUtil = require('../../utils/unread.js');

Page({
  data: {
    statusBarHeight: 0,
    current: 0,
    activities: [],
    location: '定位中...',
    aMapKey: 'b2dec638f9508c079a4da1c7262ca67a',
    // 位置相关
    latitude: null, // 🔥 不使用默认位置，必须真实定位
    longitude: null, // 🔥 不使用默认位置，必须真实定位
    // 加载状态
    loading: false,
    hasMore: true,
    page: 1,
    // 🔔 未读消息
    hasUnread: false, // 是否有未读消息
    totalUnread: 0, // 总未读数量
    // 🔐 登录状态
    isLoggedIn: false // 是否已登录
  },

  onLoad() {
    console.log('🏠 =============== Main页面加载开始 ===============');
    
    // 获取系统状态栏高度
    const windowInfo = wx.getWindowInfo();
    this.setData({
      statusBarHeight: windowInfo.statusBarHeight
    });
    
    // 🔥 获取用户位置（成功后会自动加载活动列表）
    this.getUserLocation();
    
    // 🔥 不预加载活动列表，必须等待真实定位成功
  },

  onShow() {
    // 🔔 自动初始化通知组件（由 app.js 全局处理）
    app.autoInitNotification();
    
    // 🔐 检查登录状态
    const isLoggedIn = storage.isLoggedIn();
    this.setData({ isLoggedIn });
    console.log('🔐 首页登录状态:', isLoggedIn);
    
    // 🔔 更新未读消息状态
    this.updateUnreadStatus();
    
    // 检查是否从地图页面返回，并获取选择的位置
    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];
    
    // 🔥 从地图页面返回时，会设置临时位置数据
    if (currentPage.data._selectedLocation) {
      const selectedLocation = currentPage.data._selectedLocation;
      console.log('📍 Main页面 - 从地图页面返回，使用选择的位置:', selectedLocation);
      console.log('   地址:', selectedLocation.address);
      console.log('   经度:', selectedLocation.longitude);
      console.log('   纬度:', selectedLocation.latitude);
      
      // 🔥 先设置经纬度和临时地址
      let displayAddress = selectedLocation.address || '获取地址中...';
      
      // 🔥 如果地址还在加载中或无效，根据经纬度重新获取
      if (!selectedLocation.address || 
          selectedLocation.address === '定位中...' || 
          selectedLocation.address === '正在获取位置...' ||
          selectedLocation.address === '请选择位置') {
        console.log('⚠️ Main页面 - 地址无效，根据经纬度重新获取');
        displayAddress = '获取地址中...';
        
        // 🔥 异步获取地址（不阻塞页面）
        this.getAddressFromLocation(selectedLocation.latitude, selectedLocation.longitude);
      }
      
      this.setData({
        location: displayAddress,
        latitude: selectedLocation.latitude,
        longitude: selectedLocation.longitude,
        page: 1,
        activities: []
      });
      
      console.log('✅ Main页面 - 位置数据已更新');
      console.log('   当前显示地址:', displayAddress);
      console.log('   当前经纬度:', selectedLocation.latitude, selectedLocation.longitude);
      
      // 清除临时数据
      currentPage.setData({
        _selectedLocation: null
      });
      
      // 🔥 重新加载活动列表（基于新的位置）
      console.log('🔄 Main页面 - 开始加载新位置的活动列表');
      this.loadActivityList();
    }
  },

  /**
   * 🔔 更新未读消息状态
   */
  updateUnreadStatus() {
    const totalUnread = unreadUtil.getTotalUnread();
    const hasUnread = totalUnread > 0;
    
    this.setData({
      hasUnread: hasUnread,
      totalUnread: totalUnread
    });
    
    console.log('🔔 首页未读消息状态:', { hasUnread, totalUnread });
  },

  // 获取用户位置
  getUserLocation() {
    const that = this;
    
    // 🔥 显示定位中状态
    this.setData({
      location: '定位中...'
    });
    
    wx.getLocation({
      type: 'gcj02',
      success(res) {
        console.log('✅ 获取位置成功:', res);
        
        // 更新经纬度
        that.setData({
          latitude: res.latitude,
          longitude: res.longitude
        });
        
        // 获取地址名称
        that.getAddressFromLocation(res.latitude, res.longitude);
        
        // 🔥 获取真实位置后，加载活动列表
        that.setData({
          page: 1,
          activities: []
        });
        that.loadActivityList();
      },
      fail(err) {
        console.error('❌ 获取位置失败:', err);
        
        // 🔥 定位失败，显示未定位
        that.setData({
          location: '未定位',
          latitude: null,
          longitude: null
        });
        
        // 提示用户开启定位权限
        wx.showModal({
          title: '获取位置失败',
          content: '需要获取您的位置信息才能查看附近活动，是否前往设置？',
          confirmText: '去设置',
          cancelText: '取消',
          success(modalRes) {
            if (modalRes.confirm) {
              wx.openSetting({
                success(settingRes) {
                  console.log('📱 用户授权结果:', settingRes);
                  // 🔥 如果用户授权了位置权限，重新获取位置
                  if (settingRes.authSetting['scope.userLocation']) {
                    console.log('✅ 用户已授权位置权限，重新获取位置');
                    that.getUserLocation();
                  }
                }
              });
            }
          }
        });
      }
    });
  },

  // 🔥 根据经纬度获取地址（与发布页面保持一致）
  getAddressFromLocation(lat, lng) {
    console.log('🗺️ Main页面 - 获取地址名称:', { latitude: lat, longitude: lng });
    
    const that = this;
    wx.request({
      url: 'https://restapi.amap.com/v3/geocode/regeo',
      data: {
        key: this.data.aMapKey,
        location: `${lng},${lat}`,
        extensions: 'base'
      },
      success(res) {
        console.log('✅ Main页面 - 获取地址成功:', res.data);
        
        if (res.data.status === '1' && res.data.regeocode) {
          const regeocode = res.data.regeocode;
          const formattedAddress = regeocode.formatted_address;
          
          // 🔥 优先使用POI名称，否则使用详细地址（与发布页面一致）
          let address = formattedAddress;
          if (regeocode.pois && regeocode.pois.length > 0) {
            const poi = regeocode.pois[0];
            address = poi.name || formattedAddress;
          }
          
          console.log('📍 Main页面 - 设置地址:', address);
          that.setData({ 
            location: address
          });
        } else {
          console.warn('⚠️ Main页面 - 地址解析失败');
          that.setData({ 
            location: '定位失败'
          });
        }
      },
      fail(err) {
        console.error('❌ Main页面 - 获取地址失败:', err);
        that.setData({ 
          location: '定位失败'
        });
      }
    });
  },

  // 🚀 加载活动列表（调用真实API）
  loadActivityList(callback) {
    if (this.data.loading) {
      console.log('⚠️ 正在加载中，忽略重复请求');
      return;
    }
    
    // 🔥 检查是否有真实位置
    if (!this.data.latitude || !this.data.longitude) {
      console.warn('⚠️ 没有真实位置信息，无法加载活动列表');
      wx.showToast({
        title: '请先开启定位',
        icon: 'none',
        duration: 2000
      });
      callback && callback();
      return;
    }

    console.log('🔄 =============== 开始加载活动列表 ===============');
    console.log('📊 请求参数:');
    console.log('   纬度:', this.data.latitude);
    console.log('   经度:', this.data.longitude);
    console.log('   半径: 50公里');
    console.log('   页码:', this.data.page);
    console.log('   每页数量: 20');

    const that = this;
    
    // 设置加载状态
    this.setData({ loading: true });

    // 构建请求参数（不包含timestamp，会在加密时自动添加）
    const requestData = {
      latitude: this.data.latitude,
      longitude: this.data.longitude,
      radius: 50.0, // 搜索半径（公里）
      limit: 20, // 每页数量
      page: this.data.page,
      sort_by: 'distance_time', // 🔥 排序方式：综合距离和时间
      order: 'asc'  // 🔥 升序：先显示距离近且时间新的活动
    };

    console.log('📦 原始请求数据:', requestData);
    console.log('🔄 排序方式: 距离+时间综合排序（优先显示离你近的最新活动）');

    // 🔐 使用AES加密（与Flutter保持一致）
    const encryptedPayload = this.encryptData(requestData);
    
    if (!encryptedPayload) {
      console.error('❌ 加密失败，终止请求');
      this.setData({ loading: false });
      wx.showToast({
        title: '加密失败',
        icon: 'none'
      });
      callback && callback();
      return;
    }
    
    console.log('🚀 发送加密请求到: /activities/nearby/');
    console.log('📦 加密载荷:', encryptedPayload);

    // 发送请求（使用统一的BASE_URL）
    wx.request({
      url: `${request.BASE_URL}/activities/nearby/`,
      method: 'POST',
      header: {
        'Content-Type': 'application/json'
      },
      data: encryptedPayload, // 使用加密数据
      success(res) {
        console.log('📨 活动列表响应:', res);
        
        if (res.statusCode === 200 && res.data.status === 'success') {
          console.log('✅ 活动列表加载成功');
          
          const newActivities = res.data.data || [];
          console.log('📊 新增活动数量:', newActivities.length);
          
          // 处理活动数据（转换为抖音式格式）
          const processedActivities = that.processActivityData(newActivities);
          
          // 🔥 前端排序：优先距离，其次时间（解决后端排序问题）
          processedActivities.sort((a, b) => {
            // 1️⃣ 首先按距离排序（距离相差超过1公里，优先距离）
            const distanceDiff = a.distance - b.distance;
            if (Math.abs(distanceDiff) > 1) {
              return distanceDiff; // 距离差大于1km，按距离排序
            }
            
            // 2️⃣ 距离相近时，按时间排序（新的排前面）
            const timeA = new Date(a.activityPublishTime).getTime();
            const timeB = new Date(b.activityPublishTime).getTime();
            return timeB - timeA; // 时间降序（新的排前面）
          });
          
          console.log('✅ 前端排序完成（优先距离，其次时间）');
          console.log('📊 排序后前5个活动:');
          processedActivities.slice(0, 5).forEach((activity, index) => {
            console.log(`   ${index + 1}. ${activity.activityTitle} - ${activity.distanceText} | ${activity.timeText}`);
          });
          
          // 合并数据
          const activityList = that.data.page === 1 
            ? processedActivities 
            : [...that.data.activities, ...processedActivities];
          
          // 判断是否还有更多数据
          const hasMore = newActivities.length >= 20;
          
          that.setData({
            activities: activityList,
            hasMore: hasMore,
            loading: false
          });
          
          console.log('📱 当前活动总数:', activityList.length);
          console.log('📄 是否还有更多:', hasMore);
        } else {
          console.log('❌ 活动列表加载失败:', res.data.message);
          that.setData({ loading: false });
          
          wx.showToast({
            title: res.data.message || '加载失败',
            icon: 'none'
          });
        }
        
        // 执行回调
        callback && callback();
      },
      fail(err) {
        console.log('💥 活动列表请求失败:', err);
        that.setData({ loading: false });
        
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
        
        // 执行回调
        callback && callback();
      }
    });
  },

  // 🔐 数据加密（AES加密 - 与Flutter保持一致）
  encryptData(data) {
    try {
      console.log('🔐 开始AES加密');
      console.log('📝 原始数据:', JSON.stringify(data));
      
      // 🔑 AES密钥（32字节，与Flutter保持一致）
      const SECRET_KEY = 'qwertyuiop1234567654zaqwsxcderfv';
      
      // 添加时间戳（秒级，数字类型）
      const dataWithTimestamp = Object.assign({}, data);
      const timestamp = Math.floor(Date.now() / 1000);
      dataWithTimestamp.timestamp = timestamp;
      
      console.log('⏰ 添加时间戳:', timestamp);
      console.log('📊 完整数据:', JSON.stringify(dataWithTimestamp));
      
      // 转换为JSON字符串
      const jsonString = JSON.stringify(dataWithTimestamp);
      console.log('📄 JSON字符串:', jsonString);
      
      // 🔑 生成随机IV（16字节）- 小程序兼容方式
      // 生成4个32位随机整数（16字节 = 4 x 32位）
      const words = [];
      for (let i = 0; i < 4; i++) {
        words.push((Math.random() * 0x100000000) | 0);
      }
      const iv = CryptoJS.lib.WordArray.create(words, 16);
      console.log('🔑 生成的IV:', CryptoJS.enc.Base64.stringify(iv));
      
      // 将密钥转换为WordArray
      const key = CryptoJS.enc.Utf8.parse(SECRET_KEY);
      
      // 进行加密（CBC模式，PKCS7填充）
      const encrypted = CryptoJS.AES.encrypt(jsonString, key, {
        iv: iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
      });
      
      // 🔥 正确拼接IV和加密数据（字节级别拼接）
      // 将IV转换为字节数组
      const ivBytes = [];
      for (let i = 0; i < iv.words.length; i++) {
        const word = iv.words[i];
        ivBytes.push((word >>> 24) & 0xff);
        ivBytes.push((word >>> 16) & 0xff);
        ivBytes.push((word >>> 8) & 0xff);
        ivBytes.push(word & 0xff);
      }
      
      // 将加密数据转换为字节数组
      const encryptedBytes = [];
      const cipherWords = encrypted.ciphertext.words;
      const cipherSigBytes = encrypted.ciphertext.sigBytes;
      for (let i = 0; i < cipherSigBytes; i++) {
        const byte = (cipherWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
        encryptedBytes.push(byte);
      }
      
      // 拼接IV和加密数据
      const combinedBytes = ivBytes.concat(encryptedBytes);
      
      // 转换回WordArray并进行Base64编码
      const combinedWords = [];
      for (let i = 0; i < combinedBytes.length; i += 4) {
        const word = (combinedBytes[i] << 24) | 
                     (combinedBytes[i + 1] << 16) | 
                     (combinedBytes[i + 2] << 8) | 
                     combinedBytes[i + 3];
        combinedWords.push(word);
      }
      const combinedWordArray = CryptoJS.lib.WordArray.create(combinedWords, combinedBytes.length);
      
      // Base64编码
      const encryptedData = CryptoJS.enc.Base64.stringify(combinedWordArray);
      
      console.log('📦 加密结果长度:', encryptedData.length);
      console.log('🔒 加密数据:', encryptedData);
      console.log('✅ AES加密成功');
      
      // 返回加密载荷
      return {
        encrypted_data: encryptedData
      };
    } catch (e) {
      console.log('⚠️ 加密失败，使用原始数据:', e);
      // 如果加密失败，返回原始数据（用于测试）
      return data;
    }
  },

  /**
   * 🧮 计算两点之间的距离（Haversine公式）
   * @param {number} lat1 - 起点纬度
   * @param {number} lon1 - 起点经度
   * @param {number} lat2 - 终点纬度
   * @param {number} lon2 - 终点经度
   * @returns {number} 距离（公里）
   */
  calculateDistance(lat1, lon1, lat2, lon2) {
    // 地球半径（公里）
    const R = 6371;
    
    // 将角度转换为弧度
    const toRad = (value) => (value * Math.PI) / 180;
    
    const dLat = toRad(lat2 - lat1);
    const dLon = toRad(lon2 - lon1);
    
    const a = 
      Math.sin(dLat / 2) * Math.sin(dLat / 2) +
      Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) *
      Math.sin(dLon / 2) * Math.sin(dLon / 2);
    
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    const distance = R * c;
    
    return distance;
  },

  /**
   * 🎨 格式化距离显示
   * @param {number} distance - 距离（公里）
   * @returns {string} 格式化的距离字符串
   */
  formatDistance(distance) {
    if (distance < 0.1) {
      return '<100m';
    } else if (distance < 1) {
      return `${Math.round(distance * 1000)}m`;
    } else if (distance < 100) {
      return `${distance.toFixed(1)}公里`;
    } else {
      return `${Math.round(distance)}公里`;
    }
  },

  // 📊 处理活动数据（转换为抖音式格式）
  processActivityData(activities) {
    return activities.map(activity => {
      // 🔥 实时计算距离（基于当前用户位置）
      let distance = '距离未知';
      
      if (activity.latitude && activity.longitude && 
          this.data.latitude && this.data.longitude) {
        // 计算实际距离
        const distanceKm = this.calculateDistance(
          this.data.latitude,
          this.data.longitude,
          activity.latitude,
          activity.longitude
        );
        
        // 格式化显示
        distance = this.formatDistance(distanceKm);
        
        console.log(`📍 活动 "${activity.activityTitle}" 距离计算:`, {
          用户位置: `${this.data.latitude}, ${this.data.longitude}`,
          活动位置: `${activity.latitude}, ${activity.longitude}`,
          计算距离: `${distanceKm.toFixed(2)}公里`,
          显示文本: distance,
          后端距离: activity.distance ? `${activity.distance}公里` : '未提供'
        });
      }
      
      // 性别处理
      const gender = activity.publisherGender === '女' ? 'female' : 'male';
      
      // 🔥 使用图片工具类处理图片URL（自动HTTP转HTTPS，真机要求）
      const images = imageUtil.processActivityImages(activity.activityImages);
      const authorAvatar = imageUtil.processAvatar(activity.publisherAvatar);
      
      return {
        id: activity.activityId,
        images: images,
        currentImageIndex: 0,
        title: activity.activityTitle || '活动',
        description: activity.activityDetails || '暂无详情',
        author: activity.publisherNickname || '未知用户',
        authorAvatar: authorAvatar,
        distance: distance,
        gender: gender,
        // 保留原始数据用于详情跳转
        rawData: activity
      };
    });
  },

  // 滑动切换活动
  onSwiperChange(e) {
    const current = e.detail.current;
    this.setData({
      current: current
    });
    
    // 🔥 上拉加载更多：滑到倒数第3个时自动加载下一页
    const activitiesLength = this.data.activities.length;
    const shouldLoadMore = current >= activitiesLength - 3; // 倒数第3个
    
    if (shouldLoadMore && this.data.hasMore && !this.data.loading) {
      console.log('📄 自动触发加载更多，当前索引:', current, '总数:', activitiesLength);
      this.setData({
        page: this.data.page + 1
      });
      this.loadActivityList();
    }
  },

  // 图片滑动切换
  onImageChange(e) {
    const activityIndex = e.currentTarget.dataset.activityIndex;
    const imageIndex = e.detail.current;
    const key = `activities[${activityIndex}].currentImageIndex`;
    
    this.setData({
      [key]: imageIndex
    });
  },

  // 🎯 点击活动内容跳转到详情页
  onActivityContentTap() {
    const currentActivity = this.data.activities[this.data.current];
    let activityId = currentActivity.id;
    
    // 🔥 提取纯数字ID（如果ID格式是 "real_activity_183"）
    if (activityId && activityId.toString().includes('real_activity_')) {
      activityId = activityId.toString().replace('real_activity_', '');
    }
    
    console.log('🎯 点击活动内容，跳转到详情页，原始ID:', currentActivity.id, '→ 纯数字ID:', activityId);
    
    // 🔥 跳转到活动详情页（使用 id 参数）
    wx.navigateTo({
      url: `/pages/activity-detail/index?id=${activityId}`
    });
  },

  // 🔄 下拉刷新活动列表（不重新定位）
  onRefresh() {
    if (this.data.loading) {
      console.log('⚠️ 正在刷新中，忽略重复请求');
      return;
    }
    
    console.log('🔄 =============== 下拉刷新活动列表 ===============');
    
    wx.showToast({
      title: '刷新中...',
      icon: 'loading',
      duration: 1500
    });
    
    // 重置页码和数据
    this.setData({
      page: 1,
      activities: [],
      hasMore: true,
      current: 0
    });
    
    // 重新加载活动列表
    this.loadActivityList(() => {
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1500
      });
    });
  },

  // 跳转到地图选择位置
  goToMap() {
    console.log('📍 跳转到地图页面选择位置');
    
    wx.navigateTo({
      url: `/pages/map/index?location=${this.data.location}&latitude=${this.data.latitude}&longitude=${this.data.longitude}`
    });
  },

  // 跳转到登录页面
  goToLogin() {
    console.log('🔐 跳转到登录页面');
    wx.navigateTo({
      url: '/pages/login/index'
    });
  },

  // 跳转到消息页面
  goToMessage() {
    console.log('💬 点击消息图标');
    
    // 🔐 实时检查登录状态（不依赖data.isLoggedIn，避免状态不同步）
    const isLoggedIn = storage.isLoggedIn();
    console.log('🔐 实时检查登录状态:', isLoggedIn);
    
    if (!isLoggedIn) {
      console.log('⚠️ 用户未登录，引导登录');
      wx.showModal({
        title: '需要登录',
        content: '查看消息需要先登录哦~',
        confirmText: '去登录',
        cancelText: '稍后',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/login/index'
            });
          }
        }
      });
      return;
    }
    
    // 已登录，跳转到消息页面
    console.log('✅ 用户已登录，跳转到消息页面');
    wx.navigateTo({
      url: '/pages/message/index'
    });
  },

  // 刷新定位
  refreshLocation() {
    console.log('🔄 刷新位置和活动列表');
    
    // 重新获取位置（会自动触发活动列表刷新）
    this.getUserLocation();
  },

  // 下拉刷新（如果需要）
  onPullDownRefresh() {
    console.log('🔄 下拉刷新');
    this.setData({
      page: 1,
      activities: [],
      hasMore: true
    });
    this.loadActivityList(() => {
      wx.stopPullDownRefresh();
    });
  },

  // 上拉加载更多（如果需要）
  onReachBottom() {
    console.log('📄 上拉加载更多');
    if (this.data.hasMore && !this.data.loading) {
      this.setData({
        page: this.data.page + 1
      });
      this.loadActivityList();
    }
  },

  /**
   * 🖼️ 图片加载失败处理
   */
  onMainImageError(e) {
    const activityIndex = e.currentTarget.dataset.activityIndex;
    const imageIndex = e.currentTarget.dataset.imageIndex;
    
    console.warn('⚠️ 主页图片加载失败');
    console.warn('   活动索引:', activityIndex);
    console.warn('   图片索引:', imageIndex);
    
    // 🔥 使用图片工具类获取占位图
    const placeholderImage = imageUtil.getPlaceholderImage();
    
    // 更新对应活动的图片
    if (activityIndex !== undefined && imageIndex !== undefined) {
      const activities = this.data.activities;
      if (activities[activityIndex] && activities[activityIndex].images[imageIndex]) {
        // 使用路径方式更新数组中的特定元素
        this.setData({
          [`activities[${activityIndex}].images[${imageIndex}]`]: placeholderImage
        });
        console.log('✅ 已替换为占位图');
      }
    }
  }
});

